home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / mint / editors / mjovesrc.zoo / keymaps.c < prev    next >
C/C++ Source or Header  |  1992-04-04  |  12KB  |  610 lines
  1. /***************************************************************************
  2.  * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne.  JOVE *
  3.  * is provided to you without charge, and with no warranty.  You may give  *
  4.  * away copies of JOVE, including sources, provided that this notice is    *
  5.  * included in all the files.                                              *
  6.  ***************************************************************************/
  7.  
  8. #include "jove.h"
  9. #include "list.h"
  10. #include "fp.h"
  11. #include "termcap.h"
  12. #include "chars.h"
  13. #include "disp.h"
  14. #include "re.h"
  15.  
  16. /* Up until now a keymap was an array of pointers to
  17.    data_obj's.  A data_obj was either a pointer to a built-in
  18.    command or a keyboard macro.  Now a data_obj can be a
  19.    pointer to a keymap as well, which is how prefix keys will
  20.    be handled.
  21.  
  22.    There will be a way to build keymaps and give them names,
  23.    and to look those keymaps up by name, attach them to keys.
  24.    There will be a way to specify a string of key strokes and
  25.    have a series of keymaps built automatically for those
  26.    sequences. */
  27.  
  28. private    void
  29.     fb_aux proto((data_obj *, struct keymap *, char *, char *, size_t));
  30.  
  31. private List    *keymaps;        /* list of all keymaps */
  32. private struct keymap    *mainmap;
  33. #ifdef    IPROCS
  34. private struct keymap    *procsmap;
  35. #endif
  36.  
  37. /* make a new keymap, give it name NAME, initialize the keys array
  38.    to keys, if nonzero, or make an empty one, otherwise */
  39.  
  40. private struct keymap *
  41. km_new(name, keys)
  42. char    *name;
  43. data_obj    **keys;
  44. {
  45.     struct keymap    *km;
  46.  
  47.     km = (struct keymap *) emalloc(sizeof *km);
  48.     (void) list_push(&keymaps, (UnivPtr) km);
  49.     km->Type = KEYMAP;
  50.     km->Name = name;
  51.     if (keys != NULL) {
  52.         km->k_keys = keys;
  53.         km->k_alloc_p = NO;
  54.     } else {
  55.         km->k_keys = (data_obj **) emalloc(NCHARS * sizeof (data_obj *));
  56.         byte_zero((UnivPtr) km->k_keys, NCHARS * sizeof (data_obj *));
  57.         km->k_alloc_p = YES;
  58.     }
  59.     return km;
  60. }
  61.  
  62. #ifdef    NEVER
  63.  
  64. /* free up a keymap */
  65.  
  66. private void
  67. km_destroy(km)
  68. struct keymap    *km;
  69. {
  70.     if (km->k_alloc_p == YES)
  71.         free((char *) km->k_keys);
  72.     km->k_keys = NULL;
  73.     free((char *) km);
  74. }
  75.  
  76. /* lookup a keymap by name */
  77.  
  78. private struct keymap *
  79. km_lookup(name)
  80. char    *name;
  81. {
  82.     List    *lp;
  83.  
  84.     for (lp = keymaps; lp != NULL; lp = list_next(lp))
  85.         if (strcmp(name, ((struct keymap *) list_data(lp))->Name) == 0)
  86.             break;
  87.     if (lp == NULL)
  88.         return NULL;
  89.     return (struct keymap *) list_data(lp);
  90. }
  91.  
  92. #endif
  93.  
  94. /* given a map and a key, return the object bound to that key */
  95.  
  96. #ifdef MiNT
  97. #define km_getkey(m, c)    ((m)->k_keys[(c) & 0377])
  98. #else
  99. #define km_getkey(m, c)    ((m)->k_keys[(c) & CHARMASK])
  100. #endif /* MiNT */
  101.  
  102. #ifndef    km_getkey
  103. data_obj *
  104. km_getkey(m, c)
  105. struct keymap    *m;
  106. int    c;
  107. {
  108.     return (m->k_keys[c & CHARMASK]);
  109. }
  110. #endif
  111.  
  112. private void
  113. km_setkey(m, c, d)
  114. struct keymap    *m;
  115. int    c;
  116. data_obj    *d;
  117. {
  118. #ifdef MiNT
  119.     m->k_keys[c & 0377] = d;
  120. #else
  121.     m->k_keys[c & CHARMASK] = d;
  122. #endif /* MiNT */
  123. }
  124.  
  125. /* get the currently active keymaps into km_buf */
  126.  
  127. private int
  128. get_keymaps(km_buf)
  129. struct keymap    **km_buf;
  130. {
  131.     int    nmaps = 0;
  132.  
  133. #ifdef    IPROCS
  134.     if (curbuf->b_process != NULL)
  135.         km_buf[nmaps++] = procsmap;
  136. #endif
  137.     if (curbuf->b_map != NULL)
  138.         km_buf[nmaps++] = curbuf->b_map;
  139.     km_buf[nmaps++] = mainmap;
  140.  
  141.     return nmaps;
  142. }
  143.  
  144. private struct keymap *
  145. IsPrefix(cp)
  146. data_obj    *cp;
  147. {
  148.     if (cp == NULL || (cp->Type & TYPEMASK) != KEYMAP)
  149.         return NULL;
  150.     return (struct keymap *) cp;
  151. }
  152.  
  153. /* Is `c' a prefix character */
  154.  
  155. int
  156. PrefChar(c)
  157. int    c;
  158. {
  159.     return (int) IsPrefix(km_getkey(mainmap, c));
  160. }
  161.  
  162. void
  163. UnbindC()
  164. {
  165.     char    *keys;
  166.     struct keymap    *map = mainmap;
  167.  
  168.     keys = ask((char *)NULL, ProcFmt);
  169.     for (;;) {
  170.         if (keys[1] == '\0')
  171.             break;
  172.         if ((map = IsPrefix(km_getkey(map, *keys))) == NULL)
  173.             break;
  174.         keys += 1;
  175.     }
  176.     if (keys[1] != '\0')
  177.         complain("That's not a legitimate key sequence.");
  178.     km_setkey(map, keys[0], (data_obj *)NULL);
  179. }
  180.  
  181. private void
  182. BindWMap(map, lastkey, cmd)
  183. struct keymap    *map;
  184. int    lastkey;
  185. data_obj     *cmd;
  186. {
  187.     struct keymap    *nextmap;
  188.     int    c;
  189.  
  190.     c = addgetc();
  191.     if (c == EOF) {
  192.         if (lastkey == EOF)
  193.             complain("[Empty key sequence]");
  194.         complain("[Premature end of key sequence]");
  195.     } else {
  196.         if ((nextmap = IsPrefix(km_getkey(map, c))) != NULL)
  197.             BindWMap(nextmap, c, cmd);
  198.         else {
  199.             km_setkey(map, c, cmd);
  200. #ifdef    MAC
  201.             ((struct cmd *) cmd)->c_key = c;    /* see about_j() in mac.c */
  202.             if (map->k_keys == MainKeys)
  203.                 ((struct cmd *) cmd)->c_map = F_MAINMAP;
  204.             else if (map->k_keys == EscKeys)
  205.                 ((struct cmd *) cmd)->c_map = F_PREF1MAP;
  206.             else if (map == (struct keymap *) CtlxKeys)
  207.                 ((struct cmd *) cmd)->c_map = F_PREF2MAP;
  208. #endif
  209.         }
  210.     }
  211. }
  212.  
  213. private void
  214. BindSomething(proc, map)
  215. data_obj    *(*proc) ptrproto((const char *));
  216. struct keymap    *map;
  217. {
  218.     data_obj    *d;
  219.  
  220.     if ((d = (*proc)(ProcFmt)) == NULL)
  221.         return;
  222.     s_mess(": %f %s ", d->Name);
  223.     BindWMap(map, EOF, d);
  224. }
  225.  
  226. void
  227. BindAKey()
  228. {
  229.     BindSomething(findcom, mainmap);
  230. }
  231.  
  232. void
  233. BindMac()
  234. {
  235.     BindSomething(findmac, mainmap);
  236. }
  237.  
  238. private void
  239. DescWMap(map, key)
  240. struct keymap    *map;
  241. int    key;
  242. {
  243.     data_obj    *cp = km_getkey(map, key);
  244.     struct keymap    *prefp;
  245.  
  246.     if (cp == NULL)
  247.         add_mess("is unbound.");
  248.     else if ((prefp = IsPrefix(cp)) != NULL)
  249.         DescWMap(prefp, addgetc());
  250.     else
  251.         add_mess("is bound to %s.", cp->Name);
  252. }
  253.  
  254. void
  255. KeyDesc()
  256. {
  257.     s_mess(ProcFmt);
  258.     DescWMap(mainmap, addgetc());
  259. }
  260.  
  261. private void
  262. DescMap(map, pref)
  263. struct keymap    *map;
  264. char    *pref;
  265. {
  266.     int    c1,
  267.         c2;
  268.     char    keydescbuf[40];
  269.     struct keymap    *prefp;
  270.  
  271.     for (c1 = 0; c1 < NCHARS; c1 = c2 + 1) {
  272.         c2 = c1;
  273.         if (km_getkey(map, c1) == 0)
  274.             continue;
  275.         do ; while (++c2 < NCHARS && km_getkey(map, c1) == km_getkey(map, c2));
  276.         c2 -= 1;
  277.         swritef(keydescbuf, sizeof(keydescbuf),
  278.             c1==c2? "%s %p" : c1==c2+1? "%s {%p,%p}" : "%s [%p-%p]",
  279.             pref, c1, c2);
  280.         if ((prefp = IsPrefix(km_getkey(map, c1)))!=NULL && (prefp != map))
  281.             DescMap(prefp, keydescbuf);
  282.         else
  283.             Typeout("%-18s%s", keydescbuf, km_getkey(map, c1)->Name);
  284.     }
  285. }
  286.  
  287. void
  288. DescBindings()
  289. {
  290.     TOstart("Key Bindings", TRUE);
  291.     DescMap(mainmap, NullStr);
  292.     TOstop();
  293. }
  294.  
  295. private void
  296. find_binds(dp, buf, size)
  297. data_obj    *dp;
  298. char    *buf;
  299. size_t    size;
  300. {
  301.     char    *endp;
  302.  
  303.     buf[0] = '\0';
  304.     fb_aux(dp, mainmap, (char *) NULL, buf, size);
  305.     endp = buf + strlen(buf) - 2;
  306.     if ((endp > buf) && (strcmp(endp, ", ") == 0))
  307.         *endp = '\0';
  308. }
  309.  
  310. private void
  311. fb_aux(cp, map, prefix, buf, size)
  312. register data_obj    *cp;
  313. struct keymap    *map;
  314. char    *prefix,
  315.     *buf;
  316. size_t    size;
  317. {
  318.     int    c1,
  319.         c2;
  320.     char    *bufp = buf + strlen(buf),
  321.         prefbuf[20];
  322.     struct keymap    *prefp;
  323.  
  324.     for (c1 = 0; c1 < NCHARS; c1 = c2 + 1) {
  325.         c2 = c1;
  326.         if (km_getkey(map, c1) == cp) {
  327.             do ; while (++c2 < NCHARS && km_getkey(map, c1) == km_getkey(map, c2));
  328.             c2 -= 1;
  329.             if (prefix)
  330.                 swritef(bufp, sizeof(buf) - (bufp-buf), "%s ",
  331.                     prefix);
  332.             bufp += strlen(bufp);
  333.             swritef(bufp, size - (bufp-buf),
  334.                 c1==c2? "%p" : c1==c2+1? "{%p,%p}" : "[%p-%p]",
  335.                 c1, c2);
  336.         }
  337.         if ((prefp = IsPrefix(km_getkey(map, c1)))!=NULL && (prefp != map))  {
  338.             swritef(prefbuf, sizeof(prefbuf), "%p", c1);
  339.             fb_aux(cp, prefp, prefbuf, bufp, size-(bufp-buf));
  340.         }
  341.         bufp += strlen(bufp);
  342.     }
  343. }
  344.  
  345. void
  346. DescCom()
  347. {
  348.     data_obj    *dp;
  349.     char    pattern[100],
  350.         *file = CmdDb;
  351.     const char    *doc_type;
  352.     static const char var_type[] = "Variable";
  353.     static const char cmd_type[] = "Command";
  354.     File    *fp;
  355.  
  356.     if (!strcmp(LastCmd->Name, "describe-variable")) {
  357.         doc_type = var_type;
  358.         dp = (data_obj *) findvar(ProcFmt);
  359.     } else {
  360.         doc_type = cmd_type;
  361.         dp = (data_obj *) findcom(ProcFmt);
  362.     }
  363.     if (dp == NULL)
  364.         return;
  365.     fp = open_file(file, iobuff, F_READ, YES, YES);
  366.     Placur(ILI, 0);
  367.     flushscreen();
  368.     swritef(pattern, sizeof(pattern), "^:entry \"%s\" \"%s\"$",
  369.         dp->Name, doc_type);
  370.     TOstart("Help", TRUE);
  371.     for (;;) {
  372.         if (f_gets(fp, genbuf, (size_t)LBSIZE)) {
  373.             Typeout("There is no documentation for \"%s\".", dp->Name);
  374.             break;
  375.         }
  376.         if (genbuf[0] == ':' && LookingAt(pattern, genbuf, 0)) {
  377.             /* found it ... let's print it */
  378.             if (doc_type == var_type)
  379.                 Typeout(dp->Name);
  380.             else if (doc_type == cmd_type) {
  381.                 char    binding[128];
  382.  
  383.                 find_binds(dp, binding, sizeof(binding));
  384.                 if (blnkp(binding))
  385.                     Typeout("To invoke %s, type \"ESC X %s<cr>\".",
  386.                         dp->Name, dp->Name);
  387.                 else
  388.                     Typeout("Type \"%s\" to invoke %s.",
  389.                         binding, dp->Name);
  390.